/**
 ****************************************************************************
 * <P> XML.c - implementation file for basic XML parser written in ANSI C++
 * for portability. It works by using recursion and a node tree for breaking
 * down the elements of an XML document.  </P>
 *
 * @version     V2.23
 * @author      Frank Vanden Berghen
 *
 * NOTE:
 *
 *   If you add "#define STRICT_PARSING", on the first line of this file
 *   the parser will see the following XML-stream:
 *      <a><b>some text</b><b>other text    </a>
 *   as an error. Otherwise, this tring will be equivalent to:
 *      <a><b>some text</b><b>other text</b></a>
 *
 * NOTE:
 *
 *   If you add "#define APPROXIMATE_PARSING" on the first line of this file
 *   the parser will see the following XML-stream:
 *     <data name="n1">
 *     <data name="n2">
 *     <data name="n3" />
 *   as equivalent to the following XML-stream:
 *     <data name="n1" />
 *     <data name="n2" />
 *     <data name="n3" />
 *   This can be useful for badly-formed XML-streams but prevent the use
 *   of the following XML-stream (problem is: tags at contiguous levels
 *   have the same names):
 *     <data name="n1">
 *        <data name="n2">
 *            <data name="n3" />
 *        </data>
 *     </data>
 *
 * NOTE:
 *
 *   If you add "#define _XMLPARSER_NO_MESSAGEBOX_" on the first line of this file
 *   the "openFileHelper" function will always display error messages inside the
 *   console instead of inside a message-box-window. Message-box-windows are
 *   available on windows 9x/NT/2000/XP/Vista only.
 *
 * BSD license:
 * Copyright (c) 2002, Frank Vanden Berghen
 * All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Frank Vanden Berghen nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 ****************************************************************************
 */
  #ifndef _CRT_SECURE_NO_DEPRECATE
  #define _CRT_SECURE_NO_DEPRECATE
  #endif
  #include "xmlParser.h"
  #include <cstdio>
  
  namespace VarTypes {
  #ifdef _XMLWINDOWS
  //#ifdef _DEBUG
  //#define _CRTDBG_MAP_ALLOC
  //#include <crtdbg.h>
  //#endif
  #define WIN32_LEAN_AND_MEAN
  #include <Windows.h> // to have IsTextUnicode, MultiByteToWideChar, WideCharToMultiByte to handle unicode files
                      // to have "MessageBoxA" to display error messages for openFilHelper
  #endif
  
  #include <memory.h>
  #include <assert.h>
  #include <stdio.h>
  #include <string.h>
  #include <stdlib.h>
  
  XMLCSTR XMLNode::getVersion() { return _T("v2.23"); }
  void free_XMLDLL(void *t){free(t);}
  
  static char strictUTF8Parsing=1, guessUnicodeChars=1, dropWhiteSpace=1;
  
  inline int mmin( const int t1, const int t2 ) { return t1 < t2 ? t1 : t2; }
  
  // You can modify the initialization of the variable "XMLClearTags" below
  // to change the clearTags that are currently recognized by the library.
  // The number on the second columns is the length of the string inside the
  // first column. The "<!DOCTYPE" declaration must be the second in the list.
  static ALLXMLClearTag XMLClearTags[] =
  {
      {    _T("<![CDATA["),9,  _T("]]>")      },
      {    _T("<!DOCTYPE"),9,  _T(">")        },
      {    _T("<PRE>")    ,5,  _T("</PRE>")   },
      {    _T("<Script>") ,8,  _T("</Script>")},
      {    _T("<!--")     ,4,  _T("-->")      },
      {    NULL           ,0,  NULL           }
  };
  ALLXMLClearTag* XMLNode::getClearTagTable() { return XMLClearTags; }
  
  // You can modify the initialization of the variable "XMLEntities" below
  // to change the character entities that are currently recognized by the library.
  // The number on the second columns is the length of the string inside the
  // first column. Additionally, the syntaxes "&#xA0;" and "&#160;" are recognized.
  typedef struct { XMLCSTR s; int l; XMLCHAR c;} XMLCharacterEntity;
  static XMLCharacterEntity XMLEntities[] =
  {
      { _T("&amp;" ), 5, _T('&' )},
      { _T("&lt;"  ), 4, _T('<' )},
      { _T("&gt;"  ), 4, _T('>' )},
      { _T("&quot;"), 6, _T('\"')},
      { _T("&apos;"), 6, _T('\'')},
      { NULL        , 0, '\0'    }
  };
  
  // When rendering the XMLNode to a string (using the "createXMLString" function),
  // you can ask for a beautiful formatting. This formatting is using the
  // following indentation character:
  #define INDENTCHAR _T('\t')
  
  // The following function parses the XML errors into a user friendly string.
  // You can edit this to change the output language of the library to something else.
  XMLCSTR XMLNode::getError(XMLError xerror)
  {
      switch (xerror)
      {
      case eXMLErrorNone:                  return _T("No error");
      case eXMLErrorMissingEndTag:         return _T("Warning: Unmatched end tag");
      case eXMLErrorEmpty:                 return _T("Error: No XML data");
      case eXMLErrorFirstNotStartTag:      return _T("Error: First token not start tag");
      case eXMLErrorMissingTagName:        return _T("Error: Missing start tag name");
      case eXMLErrorMissingEndTagName:     return _T("Error: Missing end tag name");
      case eXMLErrorNoMatchingQuote:       return _T("Error: Unmatched quote");
      case eXMLErrorUnmatchedEndTag:       return _T("Error: Unmatched end tag");
      case eXMLErrorUnmatchedEndClearTag:  return _T("Error: Unmatched clear tag end");
      case eXMLErrorUnexpectedToken:       return _T("Error: Unexpected token found");
      case eXMLErrorInvalidTag:            return _T("Error: Invalid tag found");
      case eXMLErrorNoElements:            return _T("Error: No elements found");
      case eXMLErrorFileNotFound:          return _T("Error: File not found");
      case eXMLErrorFirstTagNotFound:      return _T("Error: First Tag not found");
      case eXMLErrorUnknownCharacterEntity:return _T("Error: Unknown character entity");
      case eXMLErrorCharConversionError:   return _T("Error: unable to convert between UNICODE and MultiByte chars");
      case eXMLErrorCannotOpenWriteFile:   return _T("Error: unable to open file for writing");
      case eXMLErrorCannotWriteFile:       return _T("Error: cannot write into file");
  
      case eXMLErrorBase64DataSizeIsNotMultipleOf4: return _T("Warning: Base64-string length is not a multiple of 4");
      case eXMLErrorBase64DecodeTruncatedData:      return _T("Warning: Base64-string is truncated");
      case eXMLErrorBase64DecodeIllegalCharacter:   return _T("Error: Base64-string contains an illegal character");
      case eXMLErrorBase64DecodeBufferTooSmall:     return _T("Error: Base64 decode output buffer is too small");
      };
      return _T("Unknown");
  }
  
  // Here is an abstraction layer to access some common string manipulation functions.
  // The abstraction layer is currently working for gcc, Microsoft Visual Studio 6.0,
  // Microsoft Visual Studio .NET, CC (sun compiler) and Borland C++.
  // If you plan to "port" the library to a new system/compiler, all you have to do is
  // to edit the following lines.
  #ifdef XML_NO_WIDE_CHAR
  char myIsTextUnicode(const void *b, int len) { (void)b; (void)len; return FALSE; }
  #else
      #if defined (UNDER_CE) || !defined(WIN32)
      char myIsTextUnicode(const void *b, int len) // inspired by the Wine API: RtlIsTextUnicode
      {
  #ifdef sun
          // for SPARC processors: wchar_t* buffers must always be alligned, otherwise it's a char* buffer.
          if ((((unsigned long)b)%sizeof(wchar_t))!=0) return FALSE;
  #endif
          const wchar_t *s=(const wchar_t*)b;
  
          // buffer too small:
          if (len<(int)sizeof(wchar_t)) return FALSE;
  
          // odd length test
          if (len&1) return FALSE;
  
          /* only checks the first 256 characters */
          len=mmin(256,len/sizeof(wchar_t));
  
          // Check for the special byte order:
          if (*s == 0xFFFE) return FALSE;     // IS_TEXT_UNICODE_REVERSE_SIGNATURE;
          if (*s == 0xFEFF) return TRUE;      // IS_TEXT_UNICODE_SIGNATURE
  
          // checks for ASCII characters in the UNICODE stream
          int i,stats=0;
          for (i=0; i<len; i++) if (s[i]<=(unsigned short)255) stats++;
          if (stats>len/2) return TRUE;
  
          // Check for UNICODE NULL chars
          for (i=0; i<len; i++) if (!s[i]) return TRUE;
  
          return FALSE;
      }
      #else
      char myIsTextUnicode(const void *b,int l) { return (char)IsTextUnicode((CONST LPVOID)b,l,NULL); };
      #endif
  #endif
  
  #ifdef _XMLWINDOWS
  // for Microsoft Visual Studio 6.0 and Microsoft Visual Studio .NET,
      #ifdef _XMLUNICODE
          wchar_t *myMultiByteToWideChar(const char *s,int l)
          {
              int i;
              if (strictUTF8Parsing)  i=(int)MultiByteToWideChar(CP_UTF8,0             ,s,l,NULL,0);
              else                    i=(int)MultiByteToWideChar(CP_ACP ,MB_PRECOMPOSED,s,l,NULL,0);
              if (i<0) return NULL;
              wchar_t *d=(wchar_t *)malloc((i+1)*sizeof(XMLCHAR));
              if (strictUTF8Parsing)  i=(int)MultiByteToWideChar(CP_UTF8,0             ,s,l,d,i);
              else                    i=(int)MultiByteToWideChar(CP_ACP ,MB_PRECOMPOSED,s,l,d,i);
              d[i]=0;
              return d;
          }
      #else
          char *myWideCharToMultiByte(const wchar_t *s,int l)
          {
              UINT codePage=CP_ACP; if (strictUTF8Parsing) codePage=CP_UTF8;
              int i=(int)WideCharToMultiByte(codePage,  // code page
                  0,                       // performance and mapping flags
                  s,                       // wide-character string
                  l,                       // number of chars in string
                  NULL,                       // buffer for new string
                  0,                       // size of buffer
                  NULL,                    // default for unmappable chars
                  NULL                     // set when default char used
                  );
              if (i<0) return NULL;
              char *d=(char*)malloc(i+1);
              WideCharToMultiByte(codePage,  // code page
                  0,                       // performance and mapping flags
                  s,                       // wide-character string
                  l,                       // number of chars in string
                  d,                       // buffer for new string
                  i,                       // size of buffer
                  NULL,                    // default for unmappable chars
                  NULL                     // set when default char used
                  );
              d[i]=0;
              return d;
          }
      #endif
      #ifdef __BORLANDC__
      int _strnicmp(char *c1, char *c2, int l){ return strnicmp(c1,c2,l);}
      #endif
  #else
  // for gcc and CC
      #ifdef XML_NO_WIDE_CHAR
          char *myWideCharToMultiByte(const wchar_t *s, int l) { (void)s; (void)l; return NULL; }
      #else
          char *myWideCharToMultiByte(const wchar_t *s, int l)
          {
              const wchar_t *ss=s;
              int i=(int)wcsrtombs(NULL,&ss,0,NULL);
              if (i<0) return NULL;
              char *d=(char *)malloc(i+1);
              wcsrtombs(d,&s,i,NULL);
              d[i]=0;
              return d;
          }
      #endif
      #ifdef _XMLUNICODE
          wchar_t *myMultiByteToWideChar(const char *s, int l)
          {
              const char *ss=s;
              int i=(int)mbsrtowcs(NULL,&ss,0,NULL);
              if (i<0) return NULL;
              wchar_t *d=(wchar_t *)malloc((i+1)*sizeof(wchar_t));
              mbsrtowcs(d,&s,l,NULL);
              d[i]=0;
              return d;
          }
          int _tcslen(XMLCSTR c)   { return wcslen(c); }
          #ifdef sun
          // for CC
            #include <widec.h>
            int _tcsnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return wsncasecmp(c1,c2,l);}
            int _tcsicmp(XMLCSTR c1, XMLCSTR c2) { return wscasecmp(c1,c2); }
          #else
          // for gcc
            int _tcsnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return wcsncasecmp(c1,c2,l);}
            int _tcsicmp(XMLCSTR c1, XMLCSTR c2) { return wcscasecmp(c1,c2); }
          #endif
          XMLSTR _tcsstr(XMLCSTR c1, XMLCSTR c2) { return (XMLSTR)wcsstr(c1,c2); }
          XMLSTR _tcscpy(XMLSTR c1, XMLCSTR c2) { return (XMLSTR)wcscpy(c1,c2); }
          FILE *_tfopen(XMLCSTR filename,XMLCSTR mode)
          {
              char *filenameAscii=myWideCharToMultiByte(filename,0);
              FILE *f;
              if (mode[0]==_T('r')) f=fopen(filenameAscii,"rb");
              else                  f=fopen(filenameAscii,"wb");
              free(filenameAscii);
              return f;
          }
      #else
        #if defined(WIN32)
          FILE *_tfopen(XMLCSTR filename,XMLCSTR mode) { return fopen(filename,mode); }
          int _tcslen(XMLCSTR c)   { return strlen(c); }
          int _tcsnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return _strnicmp(c1,c2,l);}
          int _tcsicmp(XMLCSTR c1, XMLCSTR c2) { return _strnicmp(c1,c2,strlen(c1)>strlen(c2)?strlen(c1):strlen(c2)); }
          XMLSTR _tcsstr(XMLCSTR c1, XMLCSTR c2) { return (XMLSTR)strstr(c1,c2); }
          XMLSTR _tcscpy(XMLSTR c1, XMLCSTR c2) { return (XMLSTR)strcpy(c1,c2); }
        #else
          FILE *_tfopen(XMLCSTR filename,XMLCSTR mode) { return fopen(filename,mode); }
          int _tcslen(XMLCSTR c)   { return strlen(c); }
          int _tcsnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return strncasecmp(c1,c2,l);}
          int _tcsicmp(XMLCSTR c1, XMLCSTR c2) { return strcasecmp(c1,c2); }
          XMLSTR _tcsstr(XMLCSTR c1, XMLCSTR c2) { return (XMLSTR)strstr(c1,c2); }
          XMLSTR _tcscpy(XMLSTR c1, XMLCSTR c2) { return (XMLSTR)strcpy(c1,c2); }
        #endif
      #endif
        #if defined(WIN32)
        #else
        int _strnicmp(const char *c1,const char *c2, int l) { return strncasecmp(c1,c2,l);}
        #endif
  #endif
  
  /////////////////////////////////////////////////////////////////////////
  //      Here start the core implementation of the XMLParser library    //
  /////////////////////////////////////////////////////////////////////////
  
  // You should normally not change anything below this point.
  // For your own information, I suggest that you read the openFileHelper below:
  XMLNode XMLNode::openFileHelper(XMLCSTR filename, XMLCSTR tag)
  {
      // guess the value of the global parameter "strictUTF8Parsing"
      // (the guess is based on the first 200 bytes of the file).
      FILE *f=_tfopen(filename,_T("rb"));
      if (f)
      {
          char bb[205];
          int l=(int)fread(bb,1,200,f);
          setGlobalOptions(guessUnicodeChars,guessUTF8ParsingParameterValue(bb,l),dropWhiteSpace);
          fclose(f);
      }
  
      // parse the file
      XMLResults pResults;
      XMLNode xnode=XMLNode::parseFile(filename,tag,&pResults);
  
      // display error message (if any)
      if (pResults.error != eXMLErrorNone)
      {
          // create message
          char message[2000],*s1=(char*)"",*s3=(char*)""; XMLCSTR s2=_T("");
          if (pResults.error==eXMLErrorFirstTagNotFound) { s1=(char*)"First Tag should be '"; s2=tag; s3=(char*)"'.\n"; }
          sprintf(message,
  #ifdef _XMLUNICODE
              "XML Parsing error inside file '%S'.\n%S\nAt line %i, column %i.\n%s%S%s"
  #else
              "XML Parsing error inside file '%s'.\n%s\nAt line %i, column %i.\n%s%s%s"
  #endif
              ,filename,XMLNode::getError(pResults.error),pResults.nLine,pResults.nColumn,s1,s2,s3);
  
          // display message
  #if defined(WIN32) && !defined(UNDER_CE) && !defined(_XMLPARSER_NO_MESSAGEBOX_)
          MessageBoxA(NULL,message,"XML Parsing error",MB_OK|MB_ICONERROR|MB_TOPMOST);
  #else
          printf("%s",message);
  #endif
          xnode = XMLNode::createXMLTopNode(tag);
          
      }
      return xnode;
  }
  
  #ifndef _XMLUNICODE
  // If "strictUTF8Parsing=0" then we assume that all characters have the same length of 1 byte.
  // If "strictUTF8Parsing=1" then the characters have different lengths (from 1 byte to 4 bytes).
  // This table is used as lookup-table to know the length of a character (in byte) based on the
  // content of the first byte of the character.
  // (note: if you modify this, you must always have XML_utf8ByteTable[0]=0 ).
  static const char XML_utf8ByteTable[256] =
  {
      //  0 1 2 3 4 5 6 7 8 9 a b c d e f
      0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x00
      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x10
      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x20
      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x30
      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x40
      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x50
      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x60
      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x70End of ASCII range
      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x80 0x80 to 0xc1 invalid
      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x90
      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xa0
      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xb0
      1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xc0 0xc2 to 0xdf 2 byte
      2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xd0
      3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,// 0xe0 0xe0 to 0xef 3 byte
      4,4,4,4,4,1,1,1,1,1,1,1,1,1,1,1 // 0xf0 0xf0 to 0xf4 4 byte, 0xf5 and higher invalid
  };
  static const char XML_asciiByteTable[256] =
  {
      0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
  };
  static const char *XML_ByteTable=(const char *)XML_utf8ByteTable; // the default is "strictUTF8Parsing=1"
  #endif
  
  XMLError XMLNode::writeToFile(XMLCSTR filename, const char *encoding, char nFormat) const
  {
      int i;
      XMLSTR t=createXMLString(nFormat,&i);
      FILE *f=_tfopen(filename,_T("wb"));
      if (!f) return eXMLErrorCannotOpenWriteFile;
  #ifdef _XMLUNICODE
      unsigned char h[2]={ 0xFF, 0xFE };
      if (!fwrite(h,2,1,f)) return eXMLErrorCannotWriteFile;
      if (!isDeclaration())
      {
          if (!fwrite(_T("<?xml version=\"1.0\" encoding=\"utf-16\"?>\n"),sizeof(wchar_t)*40,1,f))
              return eXMLErrorCannotWriteFile;
      }
  #else
      if (!isDeclaration())
      {
          if ((!encoding)||(XML_ByteTable==XML_utf8ByteTable))
          {
              // header so that windows recognize the file as UTF-8:
              unsigned char h[3]={0xEF,0xBB,0xBF};
              if (!fwrite(h,3,1,f)) return eXMLErrorCannotWriteFile;
              if (!fwrite("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n",39,1,f)) return eXMLErrorCannotWriteFile;
          }
          else
              if (fprintf(f,"<?xml version=\"1.0\" encoding=\"%s\"?>\n",encoding)<0) return eXMLErrorCannotWriteFile;
      } else
      {
          if (XML_ByteTable==XML_utf8ByteTable) // test if strictUTF8Parsing==1"
          {
              unsigned char h[3]={0xEF,0xBB,0xBF}; if (!fwrite(h,3,1,f)) return eXMLErrorCannotWriteFile;
          }
      }
  #endif
      if (!fwrite(t,sizeof(XMLCHAR)*i,1,f)) return eXMLErrorCannotWriteFile;
      if (fclose(f)!=0) return eXMLErrorCannotWriteFile;
      free(t);
      return eXMLErrorNone;
  }
  
  // Duplicate a given string.
  XMLSTR stringDup(XMLCSTR lpszData, int cbData)
  {
      if (lpszData==NULL) return NULL;
  
      XMLSTR lpszNew;
      if (cbData==0) cbData=(int)_tcslen(lpszData);
      lpszNew = (XMLSTR)malloc((cbData+1) * sizeof(XMLCHAR));
      if (lpszNew)
      {
          memcpy(lpszNew, lpszData, (cbData) * sizeof(XMLCHAR));
          lpszNew[cbData] = (XMLCHAR)NULL;
      }
      return lpszNew;
  }
  
  XMLNode XMLNode::emptyXMLNode;
  XMLClear XMLNode::emptyXMLClear={ NULL, NULL, NULL};
  XMLAttribute XMLNode::emptyXMLAttribute={ NULL, NULL};
  
  // Enumeration used to decipher what type a token is
  typedef enum XMLTokenTypeTag
  {
      eTokenText = 0,
      eTokenQuotedText,
      eTokenTagStart,         /* "<"            */
      eTokenTagEnd,           /* "</"           */
      eTokenCloseTag,         /* ">"            */
      eTokenEquals,           /* "="            */
      eTokenDeclaration,      /* "<?"           */
      eTokenShortHandClose,   /* "/>"           */
      eTokenClear,
      eTokenError
  } XMLTokenType;
  
  // Main structure used for parsing XML
  typedef struct XML
  {
      XMLCSTR                lpXML;
      XMLCSTR                lpszText;
      int                    nIndex,nIndexMissigEndTag;
      enum XMLError          error;
      XMLCSTR                lpEndTag;
      int                    cbEndTag;
      XMLCSTR                lpNewElement;
      int                    cbNewElement;
      int                    nFirst;
  } XML;
  
  typedef struct
  {
      ALLXMLClearTag *pClr;
      XMLCSTR     pStr;
  } NextToken;
  
  // Enumeration used when parsing attributes
  typedef enum Attrib
  {
      eAttribName = 0,
      eAttribEquals,
      eAttribValue
  } Attrib;
  
  // Enumeration used when parsing elements to dictate whether we are currently
  // inside a tag
  typedef enum Status
  {
      eInsideTag = 0,
      eOutsideTag
  } Status;
  
  // private (used while rendering):
  XMLSTR toXMLString(XMLSTR dest,XMLCSTR source)
  {
      XMLSTR dd=dest;
      XMLCHAR ch;
      XMLCharacterEntity *entity;
      while ((ch=*source))
      {
          entity=XMLEntities;
          do
          {
              if (ch==entity->c) {_tcscpy(dest,entity->s); dest+=entity->l; source++; goto out_of_loop1; }
              entity++;
          } while(entity->s);
  #ifdef _XMLUNICODE
          *(dest++)=*(source++);
  #else
          switch(XML_ByteTable[(unsigned char)ch])
          {
          case 4: *(dest++)=*(source++);
          case 3: *(dest++)=*(source++);
          case 2: *(dest++)=*(source++);
          case 1: *(dest++)=*(source++);
          }
  #endif
  out_of_loop1:
          ;
      }
      *dest=0;
      return dd;
  }
  
  // private (used while rendering):
  int lengthXMLString(XMLCSTR source)
  {
      int r=0;
      XMLCharacterEntity *entity;
      XMLCHAR ch;
      while ((ch=*source))
      {
          entity=XMLEntities;
          do
          {
              if (ch==entity->c) { r+=entity->l; source++; goto out_of_loop1; }
              entity++;
          } while(entity->s);
  #ifdef _XMLUNICODE
          r++; source++;
  #else
          ch=XML_ByteTable[(unsigned char)ch]; r+=ch; source+=ch;
  #endif
  out_of_loop1:
          ;
      }
      return r;
  }
  
  XMLSTR toXMLString(XMLCSTR source)
  {
      XMLSTR dest=(XMLSTR)malloc((lengthXMLString(source)+1)*sizeof(XMLCHAR));
      return toXMLString(dest,source);
  }
  
  XMLSTR toXMLStringFast(XMLSTR *dest,int *destSz, XMLCSTR source)
  {
      int l=lengthXMLString(source)+1;
      if (l>*destSz) { *destSz=l; *dest=(XMLSTR)realloc(*dest,l*sizeof(XMLCHAR)); }
      return toXMLString(*dest,source);
  }
  
  // private:
  XMLSTR fromXMLString(XMLCSTR s, int lo, XML *pXML)
  {
      // This function is the opposite of the function "toXMLString". It decodes the escape
      // sequences &amp;, &quot;, &apos;, &lt;, &gt; and replace them by the characters
      // &,",',<,>. This function is used internally by the XML Parser. All the calls to
      // the XML library will always gives you back "decoded" strings.
      //
      // in: string (s) and length (lo) of string
      // out:  new allocated string converted from xml
      if (!s) return NULL;
  
      int ll=0,j;
      XMLSTR d;
      XMLCSTR ss=s;
      XMLCharacterEntity *entity;
      while ((lo>0)&&(*s))
      {
          if (*s==_T('&'))
          {
              if ((lo>2)&&(s[1]==_T('#')))
              {
                  s+=2; lo-=2;
                  if ((*s==_T('X'))||(*s==_T('x'))) { s++; lo--; }
                  while ((*s)&&(*s!=_T(';'))&&((lo--)>0)) s++;
                  if (*s!=_T(';'))
                  {
                      pXML->error=eXMLErrorUnknownCharacterEntity;
                      return NULL;
                  }
                  s++; lo--;
              } else
              {
                  entity=XMLEntities;
                  do
                  {
                      if ((lo>=entity->l)&&(_tcsnicmp(s,entity->s,entity->l)==0)) { s+=entity->l; lo-=entity->l; break; }
                      entity++;
                  } while(entity->s);
                  if (!entity->s)
                  {
                      pXML->error=eXMLErrorUnknownCharacterEntity;
                      return NULL;
                  }
              }
          } else
          {
  #ifdef _XMLUNICODE
              s++; lo--;
  #else
              j=XML_ByteTable[(unsigned char)*s]; s+=j; lo-=j; ll+=j-1;
  #endif
          }
          ll++;
      }
  
      d=(XMLSTR)malloc((ll+1)*sizeof(XMLCHAR));
      s=d;
      while (ll-->0)
      {
          if (*ss==_T('&'))
          {
              if (ss[1]==_T('#'))
              {
                  ss+=2; j=0;
                  if ((*ss==_T('X'))||(*ss==_T('x')))
                  {
                      ss++;
                      while (*ss!=_T(';'))
                      {
                          if ((*ss>=_T('0'))&&(*ss<=_T('9'))) j=(j<<4)+*ss-_T('0');
                          else if ((*ss>=_T('A'))&&(*ss<=_T('F'))) j=(j<<4)+*ss-_T('A')+10;
                          else if ((*ss>=_T('a'))&&(*ss<=_T('f'))) j=(j<<4)+*ss-_T('a')+10;
                          else { free((void*)s); pXML->error=eXMLErrorUnknownCharacterEntity;return NULL;}
                          ss++;
                      }
                  } else
                  {
                      while (*ss!=_T(';'))
                      {
                          if ((*ss>=_T('0'))&&(*ss<=_T('9'))) j=(j*10)+*ss-_T('0');
                          else { free((void*)s); pXML->error=eXMLErrorUnknownCharacterEntity;return NULL;}
                          ss++;
                      }
                  }
                  (*d++)=(XMLCHAR)j; ss++;
              } else
              {
                  entity=XMLEntities;
                  do
                  {
                      if (_tcsnicmp(ss,entity->s,entity->l)==0) { *(d++)=entity->c; ss+=entity->l; break; }
                      entity++;
                  } while(entity->s);
              }
          } else
          {
  #ifdef _XMLUNICODE
              *(d++)=*(ss++);
  #else
              switch(XML_ByteTable[(unsigned char)*ss])
              {
              case 4: *(d++)=*(ss++); ll--;
              case 3: *(d++)=*(ss++); ll--;
              case 2: *(d++)=*(ss++); ll--;
              case 1: *(d++)=*(ss++);
              }
  #endif
          }
      }
      *d=0;
      return (XMLSTR)s;
  }
  
  #define XML_isSPACECHAR(ch) ((ch==_T('\n'))||(ch==_T(' '))||(ch== _T('\t'))||(ch==_T('\r')))
  
  // private:
  char myTagCompare(XMLCSTR cclose, XMLCSTR copen)
  // !!!! WARNING strange convention&:
  // return 0 if equals
  // return 1 if different
  {
      if (!cclose) return 1;
      int l=(int)_tcslen(cclose);
      if (_tcsnicmp(cclose, copen, l)!=0) return 1;
      const XMLCHAR c=copen[l];
      if (XML_isSPACECHAR(c)||
          (c==_T('/' ))||
          (c==_T('<' ))||
          (c==_T('>' ))||
          (c==_T('=' ))) return 0;
      return 1;
  }
  
  // Obtain the next character from the string.
  static inline XMLCHAR getNextChar(XML *pXML)
  {
      XMLCHAR ch = pXML->lpXML[pXML->nIndex];
  #ifdef _XMLUNICODE
      if (ch!=0) pXML->nIndex++;
  #else
      pXML->nIndex+=XML_ByteTable[(unsigned char)ch];
  #endif
      return ch;
  }
  
  // Find the next token in a string.
  // pcbToken contains the number of characters that have been read.
  static NextToken GetNextToken(XML *pXML, int *pcbToken, enum XMLTokenTypeTag *pType)
  {
      NextToken        result;
      XMLCHAR            ch;
      XMLCHAR            chTemp;
      int              indexStart,nFoundMatch,nIsText=FALSE;
      result.pClr=NULL; // prevent warning
  
      // Find next non-white space character
      do { indexStart=pXML->nIndex; ch=getNextChar(pXML); } while XML_isSPACECHAR(ch);
  
      if (ch)
      {
          // Cache the current string pointer
          result.pStr = &pXML->lpXML[indexStart];
  
          // First check whether the token is in the clear tag list (meaning it
          // does not need formatting).
          ALLXMLClearTag *ctag=XMLClearTags;
          do
          {
              if (_tcsnicmp(ctag->lpszOpen, result.pStr, ctag->openTagLen)==0)
              {
                  result.pClr=ctag;
                  pXML->nIndex+=ctag->openTagLen-1;
                  *pType=eTokenClear;
                  return result;
              }
              ctag++;
          } while(ctag->lpszOpen);
  
          // If we didn't find a clear tag then check for standard tokens
          switch(ch)
          {
          // Check for quotes
          case _T('\''):
          case _T('\"'):
              // Type of token
              *pType = eTokenQuotedText;
              chTemp = ch;
  
              // Set the size
              nFoundMatch = FALSE;
  
              // Search through the string to find a matching quote
              while((ch = getNextChar(pXML)))
              {
                  if (ch==chTemp) { nFoundMatch = TRUE; break; }
                  if (ch==_T('<')) break;
              }
  
              // If we failed to find a matching quote
              if (nFoundMatch == FALSE)
              {
                  pXML->nIndex=indexStart+1;
                  nIsText=TRUE;
                  break;
              }
  
  //  4.02.2002
  //            if (FindNonWhiteSpace(pXML)) pXML->nIndex--;
  
              break;
  
          // Equals (used with attribute values)
          case _T('='):
              *pType = eTokenEquals;
              break;
  
          // Close tag
          case _T('>'):
              *pType = eTokenCloseTag;
              break;
  
          // Check for tag start and tag end
          case _T('<'):
  
              // Peek at the next character to see if we have an end tag '</',
              // or an xml declaration '<?'
              chTemp = pXML->lpXML[pXML->nIndex];
  
              // If we have a tag end...
              if (chTemp == _T('/'))
              {
                  // Set the type and ensure we point at the next character
                  getNextChar(pXML);
                  *pType = eTokenTagEnd;
              }
  
              // If we have an XML declaration tag
              else if (chTemp == _T('?'))
              {
  
                  // Set the type and ensure we point at the next character
                  getNextChar(pXML);
                  *pType = eTokenDeclaration;
              }
  
              // Otherwise we must have a start tag
              else
              {
                  *pType = eTokenTagStart;
              }
              break;
  
          // Check to see if we have a short hand type end tag ('/>').
          case _T('/'):
  
              // Peek at the next character to see if we have a short end tag '/>'
              chTemp = pXML->lpXML[pXML->nIndex];
  
              // If we have a short hand end tag...
              if (chTemp == _T('>'))
              {
                  // Set the type and ensure we point at the next character
                  getNextChar(pXML);
                  *pType = eTokenShortHandClose;
                  break;
              }
  
              // If we haven't found a short hand closing tag then drop into the
              // text process
  
          // Other characters
          default:
              nIsText = TRUE;
          }
  
          // If this is a TEXT node
          if (nIsText)
          {
              // Indicate we are dealing with text
              *pType = eTokenText;
              while((ch = getNextChar(pXML)))
              {
                  if XML_isSPACECHAR(ch)
                  {
                      indexStart++; break;
  
                  } else if (ch==_T('/'))
                  {
                      // If we find a slash then this maybe text or a short hand end tag
                      // Peek at the next character to see it we have short hand end tag
                      ch=pXML->lpXML[pXML->nIndex];
                      // If we found a short hand end tag then we need to exit the loop
                      if (ch==_T('>')) { pXML->nIndex--; break; }
  
                  } else if ((ch==_T('<'))||(ch==_T('>'))||(ch==_T('=')))
                  {
                      pXML->nIndex--; break;
                  }
              }
          }
          *pcbToken = pXML->nIndex-indexStart;
      } else
      {
          // If we failed to obtain a valid character
          *pcbToken = 0;
          *pType = eTokenError;
          result.pStr=NULL;
      }
  
      return result;
  }
  
  XMLCSTR XMLNode::updateName_WOSD(XMLCSTR lpszName)
  {
      if (d->lpszName&&(lpszName!=d->lpszName)) free((void*)d->lpszName);
      d->lpszName=lpszName;
      return lpszName;
  }
  
  // private:
  XMLNode::XMLNode(struct XMLNodeDataTag *p){ d=p; (p->ref_count)++; }
  XMLNode::XMLNode(XMLNodeData *pParent, XMLCSTR lpszName, char isDeclaration)
  {
      d=(XMLNodeData*)malloc(sizeof(XMLNodeData));
      d->ref_count=1;
  
      d->lpszName=NULL;
      d->nChild= 0;
      d->nText = 0;
      d->nClear = 0;
      d->nAttribute = 0;
  
      d->isDeclaration = isDeclaration;
  
      d->pParent = pParent;
      d->pChild= NULL;
      d->pText= NULL;
      d->pClear= NULL;
      d->pAttribute= NULL;
      d->pOrder= NULL;
  
      updateName_WOSD(lpszName);
  }
  
  XMLNode XMLNode::createXMLTopNode_WOSD(XMLCSTR lpszName, char isDeclaration) { return XMLNode(NULL,lpszName,isDeclaration); }
  XMLNode XMLNode::createXMLTopNode(XMLCSTR lpszName, char isDeclaration) { return XMLNode(NULL,stringDup(lpszName),isDeclaration); }
  
  #define MEMORYINCREASE 50
  
  static inline void *myRealloc(void *p, int newsize, int memInc, int sizeofElem)
  {
      if (p==NULL) { if (memInc) return malloc(memInc*sizeofElem); return malloc(sizeofElem); }
      if ((memInc==0)||((newsize%memInc)==0)) p=realloc(p,(newsize+memInc)*sizeofElem);
  //    if (!p)
  //    {
  //        printf("XMLParser Error: Not enough memory! Aborting...\n"); exit(220);
  //    }
      return p;
  }
  
  // private:
  int XMLNode::findPosition(XMLNodeData *d, int index, XMLElementType xtype)
  {
      if (index<0) return -1;
      int i=0,j=(int)((index<<2)+xtype),*o=d->pOrder; while (o[i]!=j) i++; return i;
  }
  
  // private:
  // update "order" information when deleting a content of a XMLNode
  int XMLNode::removeOrderElement(XMLNodeData *d, XMLElementType t, int index)
  {
      int n=d->nChild+d->nText+d->nClear, *o=d->pOrder,i=findPosition(d,index,t);
      memmove(o+i, o+i+1, (n-i)*sizeof(int));
      for (;i<n;i++)
          if ((o[i]&3)==(int)t) o[i]-=4;
      // We should normally do:
      // d->pOrder=(int)realloc(d->pOrder,n*sizeof(int));
      // but we skip reallocation because it's too time consuming.
      // Anyway, at the end, it will be free'd completely at once.
      return i;
  }
  
  void *XMLNode::addToOrder(int memoryIncrease,int *_pos, int nc, void *p, int size, XMLElementType xtype)
  {
      //  in: *_pos is the position inside d->pOrder ("-1" means "EndOf")
      // out: *_pos is the index inside p
      p=myRealloc(p,(nc+1),memoryIncrease,size);
      int n=d->nChild+d->nText+d->nClear;
      d->pOrder=(int*)myRealloc(d->pOrder,n+1,memoryIncrease*3,sizeof(int));
      int pos=*_pos,*o=d->pOrder;
  
      if ((pos<0)||(pos>=n)) { *_pos=nc; o[n]=(int)((nc<<2)+xtype); return p; }
  
      int i=pos;
      memmove(o+i+1, o+i, (n-i)*sizeof(int));
  
      while ((pos<n)&&((o[pos]&3)!=(int)xtype)) pos++;
      if (pos==n) { *_pos=nc; o[n]=(int)((nc<<2)+xtype); return p; }
  
      o[i]=o[pos];
      for (i=pos+1;i<=n;i++) if ((o[i]&3)==(int)xtype) o[i]+=4;
  
      *_pos=pos=o[pos]>>2;
      memmove(((char*)p)+(pos+1)*size,((char*)p)+pos*size,(nc-pos)*size);
  
      return p;
  }
  
  // Add a child node to the given element.
  XMLNode XMLNode::addChild_priv(int memoryIncrease, XMLCSTR lpszName, char isDeclaration, int pos)
  {
      if (!lpszName) return emptyXMLNode;
      d->pChild=(XMLNode*)addToOrder(memoryIncrease,&pos,d->nChild,d->pChild,sizeof(XMLNode),eNodeChild);
      d->pChild[pos].d=NULL;
      d->pChild[pos]=XMLNode(d,lpszName,isDeclaration);
      d->nChild++;
      return d->pChild[pos];
  }
  
  // Add an attribute to an element.
  XMLAttribute *XMLNode::addAttribute_priv(int memoryIncrease,XMLCSTR lpszName, XMLCSTR lpszValuev)
  {
      if (!lpszName) return &emptyXMLAttribute;
      int nc=d->nAttribute;
      d->pAttribute=(XMLAttribute*)myRealloc(d->pAttribute,(nc+1),memoryIncrease,sizeof(XMLAttribute));
      XMLAttribute *pAttr=d->pAttribute+nc;
      pAttr->lpszName = lpszName;
      pAttr->lpszValue = lpszValuev;
      d->nAttribute++;
      return pAttr;
  }
  
  // Add text to the element.
  XMLCSTR XMLNode::addText_priv(int memoryIncrease, XMLCSTR lpszValue, int pos)
  {
      if (!lpszValue) return NULL;
      d->pText=(XMLCSTR*)addToOrder(memoryIncrease,&pos,d->nText,d->pText,sizeof(XMLSTR),eNodeText);
      d->pText[pos]=lpszValue;
      d->nText++;
      return lpszValue;
  }
  
  // Add clear (unformatted) text to the element.
  XMLClear *XMLNode::addClear_priv(int memoryIncrease, XMLCSTR lpszValue, XMLCSTR lpszOpen, XMLCSTR lpszClose, int pos)
  {
      if (!lpszValue) return &emptyXMLClear;
      d->pClear=(XMLClear *)addToOrder(memoryIncrease,&pos,d->nClear,d->pClear,sizeof(XMLClear),eNodeClear);
      XMLClear *pNewClear=d->pClear+pos;
      pNewClear->lpszValue = lpszValue;
      if (!lpszOpen) lpszOpen=getClearTagTable()->lpszOpen;
      if (!lpszClose) lpszOpen=getClearTagTable()->lpszClose;
      pNewClear->lpszOpenTag = lpszOpen;
      pNewClear->lpszCloseTag = lpszClose;
      d->nClear++;
      return pNewClear;
  }
  
  // private:
  // Parse a clear (unformatted) type node.
  char XMLNode::parseClearTag(void *px, ALLXMLClearTag *pClear)
  {
      XML *pXML=(XML *)px;
      int cbTemp=0;
      XMLCSTR lpszTemp=NULL;
      XMLCSTR lpXML=&pXML->lpXML[pXML->nIndex];
      static XMLCSTR docTypeEnd=_T("]>");
  
      // Find the closing tag
      // Seems the <!DOCTYPE need a better treatment so lets handle it
      if (pClear->lpszOpen==XMLClearTags[1].lpszOpen)
      {
          XMLCSTR pCh=lpXML;
          while (*pCh)
          {
              if (*pCh==_T('<')) { pClear->lpszClose=docTypeEnd; lpszTemp=_tcsstr(lpXML,docTypeEnd); break; }
              else if (*pCh==_T('>')) { lpszTemp=pCh; break; }
  #ifdef _XMLUNICODE
              pCh++;
  #else
              pCh+=XML_ByteTable[(unsigned char)(*pCh)];
  #endif
          }
      } else lpszTemp=_tcsstr(lpXML, pClear->lpszClose);
  
      if (lpszTemp)
      {
          // Cache the size and increment the index
          cbTemp = (int)(lpszTemp - lpXML);
  
          pXML->nIndex += cbTemp+(int)_tcslen(pClear->lpszClose);
  
          // Add the clear node to the current element
          addClear_priv(MEMORYINCREASE,stringDup(lpXML,cbTemp), pClear->lpszOpen, pClear->lpszClose,-1);
          return 0;
      }
  
      // If we failed to find the end tag
      pXML->error = eXMLErrorUnmatchedEndClearTag;
      return 1;
  }
  
  void XMLNode::exactMemory(XMLNodeData *d)
  {
      if (d->pOrder)     d->pOrder=(int*)realloc(d->pOrder,(d->nChild+d->nText+d->nClear)*sizeof(int));
      if (d->pChild)     d->pChild=(XMLNode*)realloc(d->pChild,d->nChild*sizeof(XMLNode));
      if (d->pAttribute) d->pAttribute=(XMLAttribute*)realloc(d->pAttribute,d->nAttribute*sizeof(XMLAttribute));
      if (d->pText)      d->pText=(XMLCSTR*)realloc(d->pText,d->nText*sizeof(XMLSTR));
      if (d->pClear)     d->pClear=(XMLClear *)realloc(d->pClear,d->nClear*sizeof(XMLClear));
  }
  
  char XMLNode::maybeAddTxT(void *pa, XMLCSTR tokenPStr)
  {
      XML *pXML=(XML *)pa;
      XMLCSTR lpszText=pXML->lpszText;
      if (!lpszText) return 0;
      if (dropWhiteSpace) while (XML_isSPACECHAR(*lpszText)&&(lpszText!=tokenPStr)) lpszText++;
      int cbText = (int)(tokenPStr - lpszText);
      if (!cbText) { pXML->lpszText=NULL; return 0; }
      if (dropWhiteSpace) { cbText--; while ((cbText)&&XML_isSPACECHAR(lpszText[cbText])) cbText--; cbText++; }
      if (!cbText) { pXML->lpszText=NULL; return 0; }
      lpszText=fromXMLString(lpszText,cbText,pXML);
      if (!lpszText) return 1;
      addText_priv(MEMORYINCREASE,lpszText,-1);
      pXML->lpszText=NULL;
      return 0;
  }
  // private:
  // Recursively parse an XML element.
  int XMLNode::ParseXMLElement(void *pa)
  {
      XML *pXML=(XML *)pa;
      int cbToken;
      enum XMLTokenTypeTag type;
      NextToken token;
      XMLCSTR lpszTemp=NULL;
      int cbTemp=0;
      char nDeclaration;
      XMLNode pNew;
      enum Status status; // inside or outside a tag
      enum Attrib attrib = eAttribName;
  
      assert(pXML);
  
      // If this is the first call to the function
      if (pXML->nFirst)
      {
          // Assume we are outside of a tag definition
          pXML->nFirst = FALSE;
          status = eOutsideTag;
      } else
      {
          // If this is not the first call then we should only be called when inside a tag.
          status = eInsideTag;
      }
  
      // Iterate through the tokens in the document
      for(;;)
      {
          // Obtain the next token
          token = GetNextToken(pXML, &cbToken, &type);
  
          if (type != eTokenError)
          {
              // Check the current status
              switch(status)
              {
  
              // If we are outside of a tag definition
              case eOutsideTag:
  
                  // Check what type of token we obtained
                  switch(type)
                  {
                  // If we have found text or quoted text
                  case eTokenText:
                  case eTokenCloseTag:          /* '>'         */
                  case eTokenShortHandClose:    /* '/>'        */
                  case eTokenQuotedText:
                  case eTokenEquals:
                      break;
  
                  // If we found a start tag '<' and declarations '<?'
                  case eTokenTagStart:
                  case eTokenDeclaration:
  
                      // Cache whether this new element is a declaration or not
                      nDeclaration = (type == eTokenDeclaration);
  
                      // If we have node text then add this to the element
                      if (maybeAddTxT(pXML,token.pStr)) return FALSE;
  
                      // Find the name of the tag
                      token = GetNextToken(pXML, &cbToken, &type);
  
                      // Return an error if we couldn't obtain the next token or
                      // it wasnt text
                      if (type != eTokenText)
                      {
                          pXML->error = eXMLErrorMissingTagName;
                          return FALSE;
                      }
  
                      // If we found a new element which is the same as this
                      // element then we need to pass this back to the caller..
  
  #ifdef APPROXIMATE_PARSING
                      if (d->lpszName &&
                          myTagCompare(d->lpszName, token.pStr) == 0)
                      {
                          // Indicate to the caller that it needs to create a
                          // new element.
                          pXML->lpNewElement = token.pStr;
                          pXML->cbNewElement = cbToken;
                          return TRUE;
                      } else
  #endif
                      {
                          // If the name of the new element differs from the name of
                          // the current element we need to add the new element to
                          // the current one and recurse
                          pNew = addChild_priv(MEMORYINCREASE,stringDup(token.pStr,cbToken), nDeclaration,-1);
  
                          while (!pNew.isEmpty())
                          {
                              // Callself to process the new node.  If we return
                              // FALSE this means we dont have any more
                              // processing to do...
  
                              if (!pNew.ParseXMLElement(pXML)) return FALSE;
                              else
                              {
                                  // If the call to recurse this function
                                  // evented in a end tag specified in XML then
                                  // we need to unwind the calls to this
                                  // function until we find the appropriate node
                                  // (the element name and end tag name must
                                  // match)
                                  if (pXML->cbEndTag)
                                  {
                                      // If we are back at the root node then we
                                      // have an unmatched end tag
                                      if (!d->lpszName)
                                      {
                                          pXML->error=eXMLErrorUnmatchedEndTag;
                                          return FALSE;
                                      }
  
                                      // If the end tag matches the name of this
                                      // element then we only need to unwind
                                      // once more...
  
                                      if (myTagCompare(d->lpszName, pXML->lpEndTag)==0)
                                      {
                                          pXML->cbEndTag = 0;
                                      }
  
                                      return TRUE;
                                  } else
                                      if (pXML->cbNewElement)
                                      {
                                          // If the call indicated a new element is to
                                          // be created on THIS element.
  
                                          // If the name of this element matches the
                                          // name of the element we need to create
                                          // then we need to return to the caller
                                          // and let it process the element.
  
                                          if (myTagCompare(d->lpszName, pXML->lpNewElement)==0)
                                          {
                                              return TRUE;
                                          }
  
                                          // Add the new element and recurse
                                          pNew = addChild_priv(MEMORYINCREASE,stringDup(pXML->lpNewElement,pXML->cbNewElement),0,-1);
                                          pXML->cbNewElement = 0;
                                      }
                                      else
                                      {
                                          // If we didn't have a new element to create
                                          pNew = emptyXMLNode;
  
                                      }
                              }
                          }
                      }
                      break;
  
                  // If we found an end tag
                  case eTokenTagEnd:
  
                      // If we have node text then add this to the element
                      if (maybeAddTxT(pXML,token.pStr)) return FALSE;
  
                      // Find the name of the end tag
                      token = GetNextToken(pXML, &cbTemp, &type);
  
                      // The end tag should be text
                      if (type != eTokenText)
                      {
                          pXML->error = eXMLErrorMissingEndTagName;
                          return FALSE;
                      }
                      lpszTemp = token.pStr;
  
                      // After the end tag we should find a closing tag
                      token = GetNextToken(pXML, &cbToken, &type);
                      if (type != eTokenCloseTag)
                      {
                          pXML->error = eXMLErrorMissingEndTagName;
                          return FALSE;
                      }
                      pXML->lpszText=pXML->lpXML+pXML->nIndex;
  
                      // We need to return to the previous caller.  If the name
                      // of the tag cannot be found we need to keep returning to
                      // caller until we find a match
                      if (myTagCompare(d->lpszName, lpszTemp) != 0)
  #ifdef STRICT_PARSING
                      {
                          pXML->error=eXMLErrorUnmatchedEndTag;
                          pXML->nIndexMissigEndTag=pXML->nIndex;
                          return FALSE;
                      }
  #else
                      {
                          pXML->error=eXMLErrorMissingEndTag;
                          pXML->nIndexMissigEndTag=pXML->nIndex;
                          pXML->lpEndTag = lpszTemp;
                          pXML->cbEndTag = cbTemp;
                      }
  #endif
  
                      // Return to the caller
                      exactMemory(d);
                      return TRUE;
  
                  // If we found a clear (unformatted) token
                  case eTokenClear:
                      // If we have node text then add this to the element
                      if (maybeAddTxT(pXML,token.pStr)) return FALSE;
                      if (parseClearTag(pXML, token.pClr)) return FALSE;
                      pXML->lpszText=pXML->lpXML+pXML->nIndex;
                      break;
  
                  default:
                      break;
                  }
                  break;
  
              // If we are inside a tag definition we need to search for attributes
              case eInsideTag:
  
                  // Check what part of the attribute (name, equals, value) we
                  // are looking for.
                  switch(attrib)
                  {
                  // If we are looking for a new attribute
                  case eAttribName:
  
                      // Check what the current token type is
                      switch(type)
                      {
                      // If the current type is text...
                      // Eg.  'attribute'
                      case eTokenText:
                          // Cache the token then indicate that we are next to
                          // look for the equals
                          lpszTemp = token.pStr;
                          cbTemp = cbToken;
                          attrib = eAttribEquals;
                          break;
  
                      // If we found a closing tag...
                      // Eg.  '>'
                      case eTokenCloseTag:
                          // We are now outside the tag
                          status = eOutsideTag;
                          pXML->lpszText=pXML->lpXML+pXML->nIndex;
                          break;
  
                      // If we found a short hand '/>' closing tag then we can
                      // return to the caller
                      case eTokenShortHandClose:
                          exactMemory(d);
                          pXML->lpszText=pXML->lpXML+pXML->nIndex;
                          return TRUE;
  
                      // Errors...
                      case eTokenQuotedText:    /* '"SomeText"'   */
                      case eTokenTagStart:      /* '<'            */
                      case eTokenTagEnd:        /* '</'           */
                      case eTokenEquals:        /* '='            */
                      case eTokenDeclaration:   /* '<?'           */
                      case eTokenClear:
                          pXML->error = eXMLErrorUnexpectedToken;
                          return FALSE;
                      default: break;
                      }
                      break;
  
                  // If we are looking for an equals
                  case eAttribEquals:
                      // Check what the current token type is
                      switch(type)
                      {
                      // If the current type is text...
                      // Eg.  'Attribute AnotherAttribute'
                      case eTokenText:
                          // Add the unvalued attribute to the list
                          addAttribute_priv(MEMORYINCREASE,stringDup(lpszTemp,cbTemp), NULL);
                          // Cache the token then indicate.  We are next to
                          // look for the equals attribute
                          lpszTemp = token.pStr;
                          cbTemp = cbToken;
                          break;
  
                      // If we found a closing tag 'Attribute >' or a short hand
                      // closing tag 'Attribute />'
                      case eTokenShortHandClose:
                      case eTokenCloseTag:
                          // If we are a declaration element '<?' then we need
                          // to remove extra closing '?' if it exists
                          pXML->lpszText=pXML->lpXML+pXML->nIndex;
  
                          if (d->isDeclaration &&
                              (lpszTemp[cbTemp-1]) == _T('?'))
                          {
                              cbTemp--;
                          }
  
                          if (cbTemp)
                          {
                              // Add the unvalued attribute to the list
                              addAttribute_priv(MEMORYINCREASE,stringDup(lpszTemp,cbTemp), NULL);
                          }
  
                          // If this is the end of the tag then return to the caller
                          if (type == eTokenShortHandClose)
                          {
                              exactMemory(d);
                              return TRUE;
                          }
  
                          // We are now outside the tag
                          status = eOutsideTag;
                          break;
  
                      // If we found the equals token...
                      // Eg.  'Attribute ='
                      case eTokenEquals:
                          // Indicate that we next need to search for the value
                          // for the attribute
                          attrib = eAttribValue;
                          break;
  
                      // Errors...
                      case eTokenQuotedText:    /* 'Attribute "InvalidAttr"'*/
                      case eTokenTagStart:      /* 'Attribute <'            */
                      case eTokenTagEnd:        /* 'Attribute </'           */
                      case eTokenDeclaration:   /* 'Attribute <?'           */
                      case eTokenClear:
                          pXML->error = eXMLErrorUnexpectedToken;
                          return FALSE;
                      default: break;
                      }
                      break;
  
                  // If we are looking for an attribute value
                  case eAttribValue:
                      // Check what the current token type is
                      switch(type)
                      {
                      // If the current type is text or quoted text...
                      // Eg.  'Attribute = "Value"' or 'Attribute = Value' or
                      // 'Attribute = 'Value''.
                      case eTokenText:
                      case eTokenQuotedText:
                          // If we are a declaration element '<?' then we need
                          // to remove extra closing '?' if it exists
                          if (d->isDeclaration &&
                              (token.pStr[cbToken-1]) == _T('?'))
                          {
                              cbToken--;
                          }
  
                          if (cbTemp)
                          {
                              // Add the valued attribute to the list
                              if (type==eTokenQuotedText) { token.pStr++; cbToken-=2; }
                              XMLCSTR attrVal=token.pStr;
                              if (attrVal)
                              {
                                  attrVal=fromXMLString(attrVal,cbToken,pXML);
                                  if (!attrVal) return FALSE;
                              }
                              addAttribute_priv(MEMORYINCREASE,stringDup(lpszTemp,cbTemp),attrVal);
                          }
  
                          // Indicate we are searching for a new attribute
                          attrib = eAttribName;
                          break;
  
                      // Errors...
                      case eTokenTagStart:        /* 'Attr = <'          */
                      case eTokenTagEnd:          /* 'Attr = </'         */
                      case eTokenCloseTag:        /* 'Attr = >'          */
                      case eTokenShortHandClose:  /* "Attr = />"         */
                      case eTokenEquals:          /* 'Attr = ='          */
                      case eTokenDeclaration:     /* 'Attr = <?'         */
                      case eTokenClear:
                          pXML->error = eXMLErrorUnexpectedToken;
                          return FALSE;
                          break;
                      default: break;
                      }
                  }
              }
          }
          // If we failed to obtain the next token
          else
          {
              if ((!d->isDeclaration)&&(d->pParent))
              {
  #ifdef STRICT_PARSING
                  pXML->error=eXMLErrorUnmatchedEndTag;
  #else
                  pXML->error=eXMLErrorMissingEndTag;
  #endif
                  pXML->nIndexMissigEndTag=pXML->nIndex;
              }
              return FALSE;
          }
      }
  }
  
  // Count the number of lines and columns in an XML string.
  static void CountLinesAndColumns(XMLCSTR lpXML, int nUpto, XMLResults *pResults)
  {
      XMLCHAR ch;
      assert(lpXML);
      assert(pResults);
  
      struct XML xml={ lpXML,lpXML, 0, 0, eXMLErrorNone, NULL, 0, NULL, 0, TRUE };
  
      pResults->nLine = 1;
      pResults->nColumn = 1;
      while (xml.nIndex<nUpto)
      {
          ch = getNextChar(&xml);
          if (ch != _T('\n')) pResults->nColumn++;
          else
          {
              pResults->nLine++;
              pResults->nColumn=1;
          }
      }
  }
  
  // Parse XML and return the root element.
  XMLNode XMLNode::parseString(XMLCSTR lpszXML, XMLCSTR tag, XMLResults *pResults)
  {
      if (!lpszXML)
      {
          if (pResults)
          {
              pResults->error=eXMLErrorNoElements;
              pResults->nLine=0;
              pResults->nColumn=0;
          }
          return emptyXMLNode;
      }
  
      XMLNode xnode(NULL,NULL,FALSE);
      struct XML xml={ lpszXML, lpszXML, 0, 0, eXMLErrorNone, NULL, 0, NULL, 0, TRUE };
  
      // Create header element
      xnode.ParseXMLElement(&xml);
      enum XMLError error = xml.error;
      if ((xnode.nChildNode()==1)&&(xnode.nElement()==1)) xnode=xnode.getChildNode(); // skip the empty node
  
      // If no error occurred
      if ((error==eXMLErrorNone)||(error==eXMLErrorMissingEndTag))
      {
          XMLCSTR name=xnode.getName();
          if (tag&&_tcslen(tag)&&((!name)||(_tcsicmp(xnode.getName(),tag))))
          {
              XMLNode nodeTmp;
              int i=0;
              while (i<xnode.nChildNode())
              {
                  nodeTmp=xnode.getChildNode(i);
                  if (_tcsicmp(nodeTmp.getName(),tag)==0) break;
                  if (nodeTmp.isDeclaration()) { xnode=nodeTmp; i=0; } else i++;
              }
              if (i>=xnode.nChildNode())
              {
                  if (pResults)
                  {
                      pResults->error=eXMLErrorFirstTagNotFound;
                      pResults->nLine=0;
                      pResults->nColumn=0;
                  }
                  return emptyXMLNode;
              }
              xnode=nodeTmp;
          }
      } else
      {
          // Cleanup: this will destroy all the nodes
          xnode = emptyXMLNode;
      }
  
  
      // If we have been given somewhere to place results
      if (pResults)
      {
          pResults->error = error;
  
          // If we have an error
          if (error!=eXMLErrorNone)
          {
              if (error==eXMLErrorMissingEndTag) xml.nIndex=xml.nIndexMissigEndTag;
              // Find which line and column it starts on.
              CountLinesAndColumns(xml.lpXML, xml.nIndex, pResults);
          }
      }
      return xnode;
  }
  
  XMLNode XMLNode::parseFile(XMLCSTR filename, XMLCSTR tag, XMLResults *pResults)
  {
      if (pResults) { pResults->nLine=0; pResults->nColumn=0; }
      FILE *f=_tfopen(filename,_T("rb"));
      if (f==NULL) { if (pResults) pResults->error=eXMLErrorFileNotFound; return emptyXMLNode; }
      fseek(f,0,SEEK_END);
      int l=ftell(f),headerSz=0;
      if (!l) { if (pResults) pResults->error=eXMLErrorEmpty; return emptyXMLNode; }
      fseek(f,0,SEEK_SET);
      unsigned char *buf=(unsigned char*)malloc(l+1);
      int tmp=fread(buf,l,1,f);
      (void)tmp;
      fclose(f);
      buf[l]=0;
  #ifdef _XMLUNICODE
      if (guessUnicodeChars)
      {
          if (!myIsTextUnicode(buf,l))
          {
              if ((buf[0]==0xef)&&(buf[1]==0xbb)&&(buf[2]==0xbf)) headerSz=3;
              XMLSTR b2=myMultiByteToWideChar((const char*)(buf+headerSz),l-headerSz);
              free(buf); buf=(unsigned char*)b2; headerSz=0;
          } else
          {
              if ((buf[0]==0xef)&&(buf[1]==0xff)) headerSz=2;
              if ((buf[0]==0xff)&&(buf[1]==0xfe)) headerSz=2;
          }
      }
  #else
      if (guessUnicodeChars)
      {
          if (myIsTextUnicode(buf,l))
          {
              l/=sizeof(wchar_t);
              if ((buf[0]==0xef)&&(buf[1]==0xff)) headerSz=2;
              if ((buf[0]==0xff)&&(buf[1]==0xfe)) headerSz=2;
              char *b2=myWideCharToMultiByte((const wchar_t*)(buf+headerSz),l-headerSz);
              free(buf); buf=(unsigned char*)b2; headerSz=0;
          } else
          {
              if ((buf[0]==0xef)&&(buf[1]==0xbb)&&(buf[2]==0xbf)) headerSz=3;
          }
      }
  #endif
  
      if (!buf) { if (pResults) pResults->error=eXMLErrorCharConversionError; return emptyXMLNode; }
      XMLNode x=parseString((XMLSTR)(buf+headerSz),tag,pResults);
      free(buf);
      return x;
  }
  
  static inline void charmemset(XMLSTR dest,XMLCHAR c,int l) { while (l--) *(dest++)=c; }
  // private:
  // Creates an user friendly XML string from a given element with
  // appropriate white space and carriage returns.
  //
  // This recurses through all subnodes then adds contents of the nodes to the
  // string.
  int XMLNode::CreateXMLStringR(XMLNodeData *pEntry, XMLSTR lpszMarker, int nFormat)
  {
      int nResult = 0;
      int cb;
      int cbElement;
      int nChildFormat=-1;
      int nElementI=pEntry->nChild+pEntry->nText+pEntry->nClear;
      int i,j;
  
      assert(pEntry);
  
  #define LENSTR(lpsz) (lpsz ? _tcslen(lpsz) : 0)
  
      // If the element has no name then assume this is the head node.
      cbElement = (int)LENSTR(pEntry->lpszName);
  
      if (cbElement)
      {
          // "<elementname "
          cb = nFormat == -1 ? 0 : nFormat;
  
          if (lpszMarker)
          {
              if (cb) charmemset(lpszMarker, INDENTCHAR, sizeof(XMLCHAR)*cb);
              nResult = cb;
              lpszMarker[nResult++]=_T('<');
              if (pEntry->isDeclaration) lpszMarker[nResult++]=_T('?');
              _tcscpy(&lpszMarker[nResult], pEntry->lpszName);
              nResult+=cbElement;
              lpszMarker[nResult++]=_T(' ');
  
          } else
          {
              nResult+=cbElement+2+cb;
              if (pEntry->isDeclaration) nResult++;
          }
  
          // Enumerate attributes and add them to the string
          XMLAttribute *pAttr=pEntry->pAttribute;
          for (i=0; i<pEntry->nAttribute; i++)
          {
              // "Attrib
              cb = (int)LENSTR(pAttr->lpszName);
              if (cb)
              {
                  if (lpszMarker) _tcscpy(&lpszMarker[nResult], pAttr->lpszName);
                  nResult += cb;
                  // "Attrib=Value "
                  if (pAttr->lpszValue)
                  {
                      cb=(int)lengthXMLString(pAttr->lpszValue);
                      if (lpszMarker)
                      {
                          lpszMarker[nResult]=_T('=');
                          lpszMarker[nResult+1]=_T('"');
                          if (cb) toXMLString(&lpszMarker[nResult+2],pAttr->lpszValue);
                          lpszMarker[nResult+cb+2]=_T('"');
                      }
                      nResult+=cb+3;
                  }
                  if (lpszMarker) lpszMarker[nResult] = _T(' ');
                  nResult++;
              }
              pAttr++;
          }
  
          if (pEntry->isDeclaration)
          {
              if (lpszMarker)
              {
                  lpszMarker[nResult-1]=_T('?');
                  lpszMarker[nResult]=_T('>');
              }
              nResult++;
              if (nFormat!=-1)
              {
                  if (lpszMarker) lpszMarker[nResult]=_T('\n');
                  nResult++;
              }
          } else
              // If there are child nodes we need to terminate the start tag
              if (nElementI)
              {
                  if (lpszMarker) lpszMarker[nResult-1]=_T('>');
                  if (nFormat!=-1)
                  {
                      if (lpszMarker) lpszMarker[nResult]=_T('\n');
                      nResult++;
                  }
              } else nResult--;
      }
  
      // Calculate the child format for when we recurse.  This is used to
      // determine the number of spaces used for prefixes.
      if (nFormat!=-1)
      {
          if (cbElement&&(!pEntry->isDeclaration)) nChildFormat=nFormat+1;
          else nChildFormat=nFormat;
      }
  
      // Enumerate through remaining children
      for (i=0; i<nElementI; i++)
      {
          j=pEntry->pOrder[i];
          switch((XMLElementType)(j&3))
          {
          // Text nodes
          case eNodeText:
              {
                  // "Text"
                  XMLCSTR pChild=pEntry->pText[j>>2];
                  cb = (int)lengthXMLString(pChild);
                  if (cb)
                  {
                      if (nFormat!=-1)
                      {
                          if (lpszMarker)
                          {
                              charmemset(&lpszMarker[nResult],INDENTCHAR,sizeof(XMLCHAR)*(nFormat + 1));
                              toXMLString(&lpszMarker[nResult+nFormat+1],pChild);
                              lpszMarker[nResult+nFormat+1+cb]=_T('\n');
                          }
                          nResult+=cb+nFormat+2;
                      } else
                      {
                          if (lpszMarker) toXMLString(&lpszMarker[nResult], pChild);
                          nResult += cb;
                      }
                  }
                  break;
              }
  
          // Clear type nodes
          case eNodeClear:
              {
                  XMLClear *pChild=pEntry->pClear+(j>>2);
                  // "OpenTag"
                  cb = (int)LENSTR(pChild->lpszOpenTag);
                  if (cb)
                  {
                      if (nFormat!=-1)
                      {
                          if (lpszMarker)
                          {
                              charmemset(&lpszMarker[nResult], INDENTCHAR, sizeof(XMLCHAR)*(nFormat + 1));
                              _tcscpy(&lpszMarker[nResult+nFormat+1], pChild->lpszOpenTag);
                          }
                          nResult+=cb+nFormat+1;
                      }
                      else
                      {
                          if (lpszMarker)_tcscpy(&lpszMarker[nResult], pChild->lpszOpenTag);
                          nResult += cb;
                      }
                  }
  
                  // "OpenTag Value"
                  cb = (int)LENSTR(pChild->lpszValue);
                  if (cb)
                  {
                      if (lpszMarker) _tcscpy(&lpszMarker[nResult], pChild->lpszValue);
                      nResult += cb;
                  }
  
                  // "OpenTag Value CloseTag"
                  cb = (int)LENSTR(pChild->lpszCloseTag);
                  if (cb)
                  {
                      if (lpszMarker) _tcscpy(&lpszMarker[nResult], pChild->lpszCloseTag);
                      nResult += cb;
                  }
  
                  if (nFormat!=-1)
                  {
                      if (lpszMarker) lpszMarker[nResult] = _T('\n');
                      nResult++;
                  }
                  break;
              }
  
          // Element nodes
          case eNodeChild:
              {
                  // Recursively add child nodes
                  nResult += CreateXMLStringR(pEntry->pChild[j>>2].d, lpszMarker ? lpszMarker + nResult : 0, nChildFormat);
                  break;
              }
          default: break;
          }
      }
  
      if ((cbElement)&&(!pEntry->isDeclaration))
      {
          // If we have child entries we need to use long XML notation for
          // closing the element - "<elementname>blah blah blah</elementname>"
          if (nElementI)
          {
              // "</elementname>\0"
              if (lpszMarker)
              {
                  if (nFormat != -1)
                  {
                      if (nFormat)
                      {
                          charmemset(&lpszMarker[nResult], INDENTCHAR,sizeof(XMLCHAR)*nFormat);
                          nResult+=nFormat;
                      }
                  }
  
                  _tcscpy(&lpszMarker[nResult], _T("</"));
                  nResult += 2;
                  _tcscpy(&lpszMarker[nResult], pEntry->lpszName);
                  nResult += cbElement;
  
                  if (nFormat == -1)
                  {
                      _tcscpy(&lpszMarker[nResult], _T(">"));
                      nResult++;
                  } else
                  {
                      _tcscpy(&lpszMarker[nResult], _T(">\n"));
                      nResult+=2;
                  }
              } else
              {
                  if (nFormat != -1) nResult+=cbElement+4+nFormat;
                  else nResult+=cbElement+3;
              }
          } else
          {
              // If there are no children we can use shorthand XML notation -
              // "<elementname/>"
              // "/>\0"
              if (lpszMarker)
              {
                  if (nFormat == -1)
                  {
                      _tcscpy(&lpszMarker[nResult], _T("/>"));
                      nResult += 2;
                  }
                  else
                  {
                      _tcscpy(&lpszMarker[nResult], _T("/>\n"));
                      nResult += 3;
                  }
              }
              else
              {
                  nResult += nFormat == -1 ? 2 : 3;
              }
          }
      }
  
      return nResult;
  }
  
  #undef LENSTR
  
  // Create an XML string
  // @param       int nFormat             - 0 if no formatting is required
  //                                        otherwise nonzero for formatted text
  //                                        with carriage returns and indentation.
  // @param       int *pnSize             - [out] pointer to the size of the
  //                                        returned string not including the
  //                                        NULL terminator.
  // @return      XMLSTR                  - Allocated XML string, you must free
  //                                        this with free().
  XMLSTR XMLNode::createXMLString(int nFormat, int *pnSize) const
  {
      if (!d) { if (pnSize) *pnSize=0; return NULL; }
  
      XMLSTR lpszResult = NULL;
      int cbStr;
  
      // Recursively Calculate the size of the XML string
      if (!dropWhiteSpace) nFormat=0;
      nFormat = nFormat ? 0 : -1;
      cbStr = CreateXMLStringR(d, 0, nFormat);
      assert(cbStr);
      // Alllocate memory for the XML string + the NULL terminator and
      // create the recursively XML string.
      lpszResult=(XMLSTR)malloc((cbStr+1)*sizeof(XMLCHAR));
      CreateXMLStringR(d, lpszResult, nFormat);
      if (pnSize) *pnSize = cbStr;
      return lpszResult;
  }
  
  XMLNode::~XMLNode() { deleteNodeContent(); }
  
  int XMLNode::detachFromParent(XMLNodeData *d)
  {
      XMLNode *pa=d->pParent->pChild;
      int i=0;
      while (((void*)(pa[i].d))!=((void*)d)) i++;
      d->pParent->nChild--;
      if (d->pParent->nChild) memmove(pa+i,pa+i+1,(d->pParent->nChild-i)*sizeof(XMLNode));
      else { free(pa); d->pParent->pChild=NULL; }
      return removeOrderElement(d->pParent,eNodeChild,i);
  }
  
  void XMLNode::deleteNodeContent(char force)
  {
      if (!d) return;
      (d->ref_count) --;
      if ((d->ref_count==0)||force)
      {
          int i;
          if (d->pParent) detachFromParent(d);
          for(i=0; i<d->nChild; i++) { d->pChild[i].d->pParent=NULL; d->pChild[i].deleteNodeContent(force); }
          free(d->pChild);
          for(i=0; i<d->nText; i++) free((void*)d->pText[i]);
          free(d->pText);
          for(i=0; i<d->nClear; i++) free((void*)d->pClear[i].lpszValue);
          free(d->pClear);
          for(i=0; i<d->nAttribute; i++)
          {
              free((void*)d->pAttribute[i].lpszName);
              if (d->pAttribute[i].lpszValue) free((void*)d->pAttribute[i].lpszValue);
          }
          free(d->pAttribute);
          free(d->pOrder);
          free((void*)d->lpszName);
          free(d);
          d=NULL;
      }
  }
  
  XMLNode XMLNode::addChild(XMLNode childNode, int pos)
  {
      XMLNodeData *dc=childNode.d;
      if ((!dc)||(!d)) return childNode;
      if (dc->pParent) { if ((detachFromParent(dc)<=pos)&&(dc->pParent==d)) pos--; } else dc->ref_count++;
      dc->pParent=d;
  //     int nc=d->nChild;
  //     d->pChild=(XMLNode*)myRealloc(d->pChild,(nc+1),memoryIncrease,sizeof(XMLNode));
      d->pChild=(XMLNode*)addToOrder(0,&pos,d->nChild,d->pChild,sizeof(XMLNode),eNodeChild);
      d->pChild[pos].d=dc;
      d->nChild++;
      return childNode;
  }
  
  void XMLNode::deleteAttribute(int i)
  {
      if ((!d)||(i<0)||(i>=d->nAttribute)) return;
      d->nAttribute--;
      XMLAttribute *p=d->pAttribute+i;
      free((void*)p->lpszName);
      if (p->lpszValue) free((void*)p->lpszValue);
      if (d->nAttribute) memmove(p,p+1,(d->nAttribute-i)*sizeof(XMLAttribute)); else { free(p); d->pAttribute=NULL; }
  }
  
  void XMLNode::deleteAttribute(XMLAttribute *a){ if (a) deleteAttribute(a->lpszName); }
  void XMLNode::deleteAttribute(XMLCSTR lpszName)
  {
      int j=0;
      getAttribute(lpszName,&j);
      if (j) deleteAttribute(j-1);
  }
  
  XMLAttribute *XMLNode::updateAttribute_WOSD(XMLCSTR lpszNewValue, XMLCSTR lpszNewName,int i)
  {
      if (!d) return NULL;
      if (i>=d->nAttribute)
      {
          if (lpszNewName) return addAttribute_WOSD(lpszNewName,lpszNewValue);
          return NULL;
      }
      XMLAttribute *p=d->pAttribute+i;
      if (p->lpszValue&&p->lpszValue!=lpszNewValue) free((void*)p->lpszValue);
      p->lpszValue=lpszNewValue;
      if (lpszNewName&&p->lpszName!=lpszNewName) { free((void*)p->lpszName); p->lpszName=lpszNewName; };
      return p;
  }
  
  XMLAttribute *XMLNode::updateAttribute_WOSD(XMLAttribute *newAttribute, XMLAttribute *oldAttribute)
  {
      if (oldAttribute) return updateAttribute_WOSD(newAttribute->lpszValue,newAttribute->lpszName,oldAttribute->lpszName);
      return addAttribute_WOSD(newAttribute->lpszName,newAttribute->lpszValue);
  }
  
  XMLAttribute *XMLNode::updateAttribute_WOSD(XMLCSTR lpszNewValue, XMLCSTR lpszNewName,XMLCSTR lpszOldName)
  {
      int j=0;
      getAttribute(lpszOldName,&j);
      if (j) return updateAttribute_WOSD(lpszNewValue,lpszNewName,j-1);
      else
      {
          if (lpszNewName) return addAttribute_WOSD(lpszNewName,lpszNewValue);
          else             return addAttribute_WOSD(stringDup(lpszOldName),lpszNewValue);
      }
  }
  
  int XMLNode::indexText(XMLCSTR lpszValue) const
  {
      if (!d) return -1;
      int i,l=d->nText;
      if (!lpszValue) { if (l) return 0; return -1; }
      XMLCSTR *p=d->pText;
      for (i=0; i<l; i++) if (lpszValue==p[i]) return i;
      return -1;
  }
  
  void XMLNode::deleteText(int i)
  {
      if ((!d)||(i<0)||(i>=d->nText)) return;
      d->nText--;
      XMLCSTR *p=d->pText+i;
      free((void*)*p);
      if (d->nText) memmove(p,p+1,(d->nText-i)*sizeof(XMLCSTR)); else { free(p); d->pText=NULL; }
      removeOrderElement(d,eNodeText,i);
  }
  
  void XMLNode::deleteText(XMLCSTR lpszValue) { deleteText(indexText(lpszValue)); }
  
  XMLCSTR XMLNode::updateText_WOSD(XMLCSTR lpszNewValue, int i)
  {
      if (!d) return NULL;
      if (i>=d->nText) return addText_WOSD(lpszNewValue);
      XMLCSTR *p=d->pText+i;
      if (*p!=lpszNewValue) { free((void*)*p); *p=lpszNewValue; }
      return lpszNewValue;
  }
  
  XMLCSTR XMLNode::updateText_WOSD(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue)
  {
      if (!d) return NULL;
      int i=indexText(lpszOldValue);
      if (i>=0) return updateText_WOSD(lpszNewValue,i);
      return addText_WOSD(lpszNewValue);
  }
  
  void XMLNode::deleteClear(int i)
  {
      if ((!d)||(i<0)||(i>=d->nClear)) return;
      d->nClear--;
      XMLClear *p=d->pClear+i;
      free((void*)p->lpszValue);
      if (d->nClear) memmove(p,p+1,(d->nText-i)*sizeof(XMLClear)); else { free(p); d->pClear=NULL; }
      removeOrderElement(d,eNodeClear,i);
  }
  
  int XMLNode::indexClear(XMLCSTR lpszValue) const
  {
      if (!d) return -1;
      int i,l=d->nClear;
      if (!lpszValue) { if (l) return 0; return -1; }
      XMLClear *p=d->pClear;
      for (i=0; i<l; i++) if (lpszValue==p[i].lpszValue) return i;
      return -1;
  }
  
  void XMLNode::deleteClear(XMLCSTR lpszValue) { deleteClear(indexClear(lpszValue)); }
  void XMLNode::deleteClear(XMLClear *a) { if (a) deleteClear(a->lpszValue); }
  
  XMLClear *XMLNode::updateClear_WOSD(XMLCSTR lpszNewContent, int i)
  {
      if (!d) return NULL;
      if (i>=d->nClear)
      {
          return addClear_WOSD(XMLClearTags[0].lpszOpen,lpszNewContent,XMLClearTags[0].lpszClose);
      }
      XMLClear *p=d->pClear+i;
      if (lpszNewContent!=p->lpszValue) { free((void*)p->lpszValue); p->lpszValue=lpszNewContent; }
      return p;
  }
  
  XMLClear *XMLNode::updateClear_WOSD(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue)
  {
      if (!d) return NULL;
      int i=indexClear(lpszOldValue);
      if (i>=0) return updateClear_WOSD(lpszNewValue,i);
      return addClear_WOSD(lpszNewValue,XMLClearTags[0].lpszOpen,XMLClearTags[0].lpszClose);
  }
  
  XMLClear *XMLNode::updateClear_WOSD(XMLClear *newP,XMLClear *oldP)
  {
      if (oldP) return updateClear_WOSD(newP->lpszValue,oldP->lpszValue);
      return NULL;
  }
  
  XMLNode& XMLNode::operator=( const XMLNode& A )
  {
      // shallow copy
      if (this != &A)
      {
          deleteNodeContent();
          d=A.d;
          if (d) (d->ref_count) ++ ;
      }
      return *this;
  }
  
  XMLNode::XMLNode(const XMLNode &A)
  {
      // shallow copy
      d=A.d;
      if (d) (d->ref_count)++ ;
  }
  
  int XMLNode::nChildNode(XMLCSTR name) const
  {
      if (!d) return 0;
      int i,j=0,n=d->nChild;
      XMLNode *pc=d->pChild;
      for (i=0; i<n; i++)
      {
          if (_tcsicmp(pc->d->lpszName, name)==0) j++;
          pc++;
      }
      return j;
  }
  
  XMLNode XMLNode::getChildNode(XMLCSTR name, int *j) const
  {
      if (!d) return emptyXMLNode;
      int i=0,n=d->nChild;
      if (j) i=*j;
      XMLNode *pc=d->pChild+i;
      for (; i<n; i++)
      {
          if (_tcsicmp(pc->d->lpszName, name)==0)
          {
              if (j) *j=i+1;
              return *pc;
          }
          pc++;
      }
      return emptyXMLNode;
  }
  
  XMLNode XMLNode::getChildNode(XMLCSTR name, int j) const
  {
      if (!d) return emptyXMLNode;
      int i=0;
      while (j-->0) getChildNode(name,&i);
      return getChildNode(name,&i);
  }
  
  int XMLNode::positionOfText     (int i) const { if (i>=d->nText ) i=d->nText-1;  return findPosition(d,i,eNodeText ); }
  int XMLNode::positionOfClear    (int i) const { if (i>=d->nClear) i=d->nClear-1; return findPosition(d,i,eNodeClear); }
  int XMLNode::positionOfChildNode(int i) const { if (i>=d->nChild) i=d->nChild-1; return findPosition(d,i,eNodeChild); }
  int XMLNode::positionOfText (XMLCSTR lpszValue) const { return positionOfText (indexText (lpszValue)); }
  int XMLNode::positionOfClear(XMLCSTR lpszValue) const { return positionOfClear(indexClear(lpszValue)); }
  int XMLNode::positionOfClear(XMLClear *a) const { if (a) return positionOfClear(a->lpszValue); return positionOfClear(); }
  int XMLNode::positionOfChildNode(XMLNode x)  const
  {
      if ((!d)||(!x.d)) return -1;
      XMLNodeData *dd=x.d;
      XMLNode *pc=d->pChild;
      int i=d->nChild;
      while (i--) if (pc[i].d==dd) return findPosition(d,i,eNodeChild);
      return -1;
  }
  int XMLNode::positionOfChildNode(XMLCSTR name, int count) const
  {
      if (!name) return positionOfChildNode(count);
      int j=0;
      do { getChildNode(name,&j); if (j<0) return -1; } while (count--);
      return findPosition(d,j-1,eNodeChild);
  }
  
  XMLNode XMLNode::getChildNodeWithAttribute(XMLCSTR name,XMLCSTR attributeName,XMLCSTR attributeValue, int *k) const
  {
      int i=0,j;
      if (k) i=*k;
      XMLNode x;
      XMLCSTR t;
      do
      {
          x=getChildNode(name,&i);
          if (!x.isEmpty())
          {
              if (attributeValue)
              {
                  j=0;
                  do
                  {
                      t=x.getAttribute(attributeName,&j);
                      if (t&&(_tcsicmp(attributeValue,t)==0)) { if (k) *k=i+1; return x; }
                  } while (t);
              } else
              {
                  if (x.isAttributeSet(attributeName)) { if (k) *k=i+1; return x; }
              }
          }
      } while (!x.isEmpty());
      return emptyXMLNode;
  }
  
  // Find an attribute on an node.
  XMLCSTR XMLNode::getAttribute(XMLCSTR lpszAttrib, int *j) const
  {
      if (!d) return NULL;
      int i=0,n=d->nAttribute;
      if (j) i=*j;
      XMLAttribute *pAttr=d->pAttribute+i;
      for (; i<n; i++)
      {
          if (_tcsicmp(pAttr->lpszName, lpszAttrib)==0)
          {
              if (j) *j=i+1;
              return pAttr->lpszValue;
          }
          pAttr++;
      }
      return NULL;
  }
  
  char XMLNode::isAttributeSet(XMLCSTR lpszAttrib) const
  {
      if (!d) return FALSE;
      int i,n=d->nAttribute;
      XMLAttribute *pAttr=d->pAttribute;
      for (i=0; i<n; i++)
      {
          if (_tcsicmp(pAttr->lpszName, lpszAttrib)==0)
          {
              return TRUE;
          }
          pAttr++;
      }
      return FALSE;
  }
  
  XMLCSTR XMLNode::getAttribute(XMLCSTR name, int j) const
  {
      if (!d) return NULL;
      int i=0;
      while (j-->0) getAttribute(name,&i);
      return getAttribute(name,&i);
  }
  
  XMLNodeContents XMLNode::enumContents(int i) const
  {
      XMLNodeContents c;
      if (!d) { c.type=eNodeNULL; return c; }
      if (i<d->nAttribute)
      {
          c.type=eNodeAttribute;
          c.attrib=d->pAttribute[i];
          return c;
      }
      i-=d->nAttribute;
      c.type=(XMLElementType)(d->pOrder[i]&3);
      i=(d->pOrder[i])>>2;
      switch (c.type)
      {
      case eNodeChild:     c.child = d->pChild[i];      break;
      case eNodeText:      c.text  = d->pText[i];       break;
      case eNodeClear:     c.clear = d->pClear[i];      break;
      default: break;
      }
      return c;
  }
  
  XMLCSTR XMLNode::getName() const { if (!d) return NULL; return d->lpszName;   }
  int XMLNode::nText()       const { if (!d) return 0;    return d->nText;      }
  int XMLNode::nChildNode()  const { if (!d) return 0;    return d->nChild;     }
  int XMLNode::nAttribute()  const { if (!d) return 0;    return d->nAttribute; }
  int XMLNode::nClear()      const { if (!d) return 0;    return d->nClear;     }
  int XMLNode::nElement()    const { if (!d) return 0;    return d->nAttribute+d->nChild+d->nText+d->nClear; }
  XMLClear     XMLNode::getClear         (int i) const { if ((!d)||(i>=d->nClear    )) return emptyXMLClear;     return d->pClear[i];     }
  XMLAttribute XMLNode::getAttribute     (int i) const { if ((!d)||(i>=d->nAttribute)) return emptyXMLAttribute; return d->pAttribute[i]; }
  XMLCSTR      XMLNode::getAttributeName (int i) const { if ((!d)||(i>=d->nAttribute)) return NULL;              return d->pAttribute[i].lpszName;  }
  XMLCSTR      XMLNode::getAttributeValue(int i) const { if ((!d)||(i>=d->nAttribute)) return NULL;              return d->pAttribute[i].lpszValue; }
  XMLCSTR      XMLNode::getText          (int i) const { if ((!d)||(i>=d->nText     )) return NULL;              return d->pText[i];      }
  XMLNode      XMLNode::getChildNode     (int i) const { if ((!d)||(i>=d->nChild    )) return emptyXMLNode;      return d->pChild[i];     }
  XMLNode      XMLNode::getParentNode    (     ) const { if ((!d)||(!d->pParent     )) return emptyXMLNode;      return XMLNode(d->pParent); }
  char         XMLNode::isDeclaration    (     ) const { if (!d) return 0;             return d->isDeclaration; }
  char         XMLNode::isEmpty          (     ) const { return (d==NULL); }
  
  XMLNode       XMLNode::addChild(XMLCSTR lpszName, char isDeclaration, int pos)
                { return addChild_priv(0,stringDup(lpszName),isDeclaration,pos); }
  XMLNode       XMLNode::addChild_WOSD(XMLCSTR lpszName, char isDeclaration, int pos)
                { return addChild_priv(0,lpszName,isDeclaration,pos); }
  XMLAttribute *XMLNode::addAttribute(XMLCSTR lpszName, XMLCSTR lpszValue)
                { return addAttribute_priv(0,stringDup(lpszName),stringDup(lpszValue)); }
  XMLAttribute *XMLNode::addAttribute_WOSD(XMLCSTR lpszName, XMLCSTR lpszValuev)
                { return addAttribute_priv(0,lpszName,lpszValuev); }
  XMLCSTR       XMLNode::addText(XMLCSTR lpszValue, int pos)
                { return addText_priv(0,stringDup(lpszValue),pos); }
  XMLCSTR       XMLNode::addText_WOSD(XMLCSTR lpszValue, int pos)
                { return addText_priv(0,lpszValue,pos); }
  XMLClear     *XMLNode::addClear(XMLCSTR lpszValue, XMLCSTR lpszOpen, XMLCSTR lpszClose, int pos)
                { return addClear_priv(0,stringDup(lpszValue),lpszOpen,lpszClose,pos); }
  XMLClear     *XMLNode::addClear_WOSD(XMLCSTR lpszValue, XMLCSTR lpszOpen, XMLCSTR lpszClose, int pos)
                { return addClear_priv(0,lpszValue,lpszOpen,lpszClose,pos); }
  XMLCSTR       XMLNode::updateName(XMLCSTR lpszName)
                { return updateName_WOSD(stringDup(lpszName)); }
  XMLAttribute *XMLNode::updateAttribute(XMLAttribute *newAttribute, XMLAttribute *oldAttribute)
                { return updateAttribute_WOSD(stringDup(newAttribute->lpszValue),stringDup(newAttribute->lpszName),oldAttribute->lpszName); }
  XMLAttribute *XMLNode::updateAttribute(XMLCSTR lpszNewValue, XMLCSTR lpszNewName,int i)
                { return updateAttribute_WOSD(stringDup(lpszNewValue),stringDup(lpszNewName),i); }
  XMLAttribute *XMLNode::updateAttribute(XMLCSTR lpszNewValue, XMLCSTR lpszNewName,XMLCSTR lpszOldName)
                { return updateAttribute_WOSD(stringDup(lpszNewValue),stringDup(lpszNewName),lpszOldName); }
  XMLCSTR       XMLNode::updateText(XMLCSTR lpszNewValue, int i)
                { return updateText_WOSD(stringDup(lpszNewValue),i); }
  XMLCSTR       XMLNode::updateText(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue)
                { return updateText_WOSD(stringDup(lpszNewValue),lpszOldValue); }
  XMLClear     *XMLNode::updateClear(XMLCSTR lpszNewContent, int i)
                { return updateClear_WOSD(stringDup(lpszNewContent),i); }
  XMLClear     *XMLNode::updateClear(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue)
                { return updateClear_WOSD(stringDup(lpszNewValue),lpszOldValue); }
  XMLClear     *XMLNode::updateClear(XMLClear *newP,XMLClear *oldP)
                { return updateClear_WOSD(stringDup(newP->lpszValue),oldP->lpszValue); }
  
  void XMLNode::setGlobalOptions(char _guessUnicodeChars, char _strictUTF8Parsing, char _dropWhiteSpace)
  {
      guessUnicodeChars=_guessUnicodeChars; dropWhiteSpace=_dropWhiteSpace; strictUTF8Parsing=_strictUTF8Parsing;
  #ifndef _XMLUNICODE
      if (_strictUTF8Parsing) XML_ByteTable=XML_utf8ByteTable; else XML_ByteTable=XML_asciiByteTable;
  #endif
  }
  
  char XMLNode::guessUTF8ParsingParameterValue(void *buf,int l, char useXMLEncodingAttribute)
  {
  #ifdef _XMLUNICODE
      return 0;
  #else
      if (l<25) return 0;
      if (myIsTextUnicode(buf,l)) return 0;
      unsigned char *b=(unsigned char*)buf;
      if ((b[0]==0xef)&&(b[1]==0xbb)&&(b[2]==0xbf)) return 1;
  
      // Match utf-8 model ?
      int i=0;
      while (i<l)
          switch (XML_utf8ByteTable[b[i]])
          {
          case 4: i++; if ((i<l)&&(b[i]& 0xC0)!=0x80) return 0; // 10bbbbbb ?
          case 3: i++; if ((i<l)&&(b[i]& 0xC0)!=0x80) return 0; // 10bbbbbb ?
          case 2: i++; if ((i<l)&&(b[i]& 0xC0)!=0x80) return 0; // 10bbbbbb ?
          case 1: i++; break;
          case 0: i=l;
          }
      if (!useXMLEncodingAttribute) return 1;
      // if encoding is specified and different from utf-8 than it's non-utf8
      // otherwise it's utf-8
      char bb[201];
      l=mmin(l,200);
      memcpy(bb,buf,l); // copy buf into bb to be able to do "bb[l]=0"
      bb[l]=0;
      b=(unsigned char*)strstr(bb,"encoding");
      if (!b) return 1;
      b+=8; while XML_isSPACECHAR(*b) b++; if (*b!='=') return 1;
      b++;  while XML_isSPACECHAR(*b) b++; if ((*b!='\'')&&(*b!='"')) return 1;
      b++;  while XML_isSPACECHAR(*b) b++; if ((_strnicmp((char*)b,"utf-8",5)==0)||
                                              (_strnicmp((char*)b,"utf8",4)==0)) return 1;
      return 0;
  #endif
  }
  #undef XML_isSPACECHAR
  
  //////////////////////////////////////////////////////////
  //      Here starts the base64 conversion functions.    //
  //////////////////////////////////////////////////////////
  
  static const char base64Fillchar = _T('='); // used to mark partial words at the end
  
  // this lookup table defines the base64 encoding
  XMLCSTR base64EncodeTable=_T("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
  
  // Decode Table gives the index of any valid base64 character in the Base64 table]
  // 96: '='  -   97: space char   -   98: illegal char   -   99: end of string
  const unsigned char base64DecodeTable[] = {
      99,98,98,98,98,98,98,98,98,97,  97,98,98,97,98,98,98,98,98,98,  98,98,98,98,98,98,98,98,98,98,  //00 -29
      98,98,97,98,98,98,98,98,98,98,  98,98,98,62,98,98,98,63,52,53,  54,55,56,57,58,59,60,61,98,98,  //30 -59
      98,96,98,98,98, 0, 1, 2, 3, 4,   5, 6, 7, 8, 9,10,11,12,13,14,  15,16,17,18,19,20,21,22,23,24,  //60 -89
      25,98,98,98,98,98,98,26,27,28,  29,30,31,32,33,34,35,36,37,38,  39,40,41,42,43,44,45,46,47,48,  //90 -119
      49,50,51,98,98,98,98,98,98,98,  98,98,98,98,98,98,98,98,98,98,  98,98,98,98,98,98,98,98,98,98,  //120 -149
      98,98,98,98,98,98,98,98,98,98,  98,98,98,98,98,98,98,98,98,98,  98,98,98,98,98,98,98,98,98,98,  //150 -179
      98,98,98,98,98,98,98,98,98,98,  98,98,98,98,98,98,98,98,98,98,  98,98,98,98,98,98,98,98,98,98,  //180 -209
      98,98,98,98,98,98,98,98,98,98,  98,98,98,98,98,98,98,98,98,98,  98,98,98,98,98,98,98,98,98,98,  //210 -239
      98,98,98,98,98,98,98,98,98,98,  98,98,98,98,98,98                                               //240 -255
  };

  int XMLParserBase64Tool::encodeLength(int inlen, char formatted)
  {
      unsigned int i=((inlen-1)/3*4+4+1);
      if (formatted) i+=inlen/54;
      return i;
  }
  
  void XMLParserBase64Tool::encode(const std::string & inString, std::string & outString, char formatted)
  {
      unsigned char *inbuf = (unsigned char*)inString.data();
      unsigned int inlen   = inString.length();
      encode(inbuf,inlen,outString,formatted);
  }
  
  void XMLParserBase64Tool::encode(unsigned char *inbuf, unsigned int inlen, std::string & outString, char formatted) {
      int i=encodeLength(inlen,formatted),k=17,eLen=inlen/3,j;
      outString.resize(i,0);
      XMLSTR curr=(XMLSTR)outString.data();
//       alloc(i*sizeof(XMLCHAR));
//       XMLSTR curr=(XMLSTR)buf;
      for(i=0;i<eLen;i++)
      {
          // Copy next three bytes into lower 24 bits of int, paying attention to sign.
          j=(inbuf[0]<<16)|(inbuf[1]<<8)|inbuf[2]; inbuf+=3;
          // Encode the int into four chars
          *(curr++)=base64EncodeTable[ j>>18      ];
          *(curr++)=base64EncodeTable[(j>>12)&0x3f];
          *(curr++)=base64EncodeTable[(j>> 6)&0x3f];
          *(curr++)=base64EncodeTable[(j    )&0x3f];
          if (formatted) { if (!k) { *(curr++)=_T('\n'); k=18; } k--; }
      }
      eLen=inlen-eLen*3; // 0 - 2.
      if (eLen==1)
      {
          *(curr++)=base64EncodeTable[ inbuf[0]>>2      ];
          *(curr++)=base64EncodeTable[(inbuf[0]<<4)&0x3F];
          *(curr++)=base64Fillchar;
          *(curr++)=base64Fillchar;
      } else if (eLen==2)
      {
          j=(inbuf[0]<<8)|inbuf[1];
          *(curr++)=base64EncodeTable[ j>>10      ];
          *(curr++)=base64EncodeTable[(j>> 4)&0x3f];
          *(curr++)=base64EncodeTable[(j<< 2)&0x3f];
          *(curr++)=base64Fillchar;
      }
      *(curr++)=0;
  }
  
  unsigned int XMLParserBase64Tool::decodeSize(XMLCSTR data,XMLError *xe)
  {
      if (xe) *xe=eXMLErrorNone;
      int size=0;
      unsigned char c;
      //skip any extra characters (e.g. newlines or spaces)
      while (*data)
      {
  #ifdef _XMLUNICODE
          if (*data>255) { if (xe) *xe=eXMLErrorBase64DecodeIllegalCharacter; return 0; }
  #endif
          c=base64DecodeTable[(unsigned char)(*data)];
          if (c<97) size++;
          else if (c==98) { if (xe) *xe=eXMLErrorBase64DecodeIllegalCharacter; return 0; }
          data++;
      }
      if (xe&&(size%4!=0)) *xe=eXMLErrorBase64DataSizeIsNotMultipleOf4;
      if (size==0) return 0;
      do { data--; size--; } while(*data==base64Fillchar); size++;
      return (unsigned int)((size*3)/4);
  }
  
  bool XMLParserBase64Tool::decode(const std::string & inString, unsigned char *buf, int len, XMLError *xe)
  {
      XMLCSTR data=inString.c_str();
      if (xe) *xe=eXMLErrorNone;
      int i=0,p=0;
      unsigned char d,c;
      for(;;)
      {
  
  #ifdef _XMLUNICODE
  #define BASE64DECODE_READ_NEXT_CHAR(c)                                              \
          do {                                                                        \
              if (data[i]>255){ c=98; break; }                                        \
              c=base64DecodeTable[(unsigned char)data[i++]];                       \
          }while (c==97);                                                             \
          if(c==98){ if(xe)*xe=eXMLErrorBase64DecodeIllegalCharacter; return false; }
  #else
  #define BASE64DECODE_READ_NEXT_CHAR(c)                                           \
          do { c=base64DecodeTable[(unsigned char)data[i++]]; }while (c==97);   \
          if(c==98){ if(xe)*xe=eXMLErrorBase64DecodeIllegalCharacter; return false; }
  #endif
  
          BASE64DECODE_READ_NEXT_CHAR(c)
          if (c==99) { return true; }
          if (c==96)
          {
              if (p==(int)len) return true;
              if (xe) *xe=eXMLErrorBase64DecodeTruncatedData;
              return true;
          }
  
          BASE64DECODE_READ_NEXT_CHAR(d)
          if ((d==99)||(d==96)) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData;  return true; }
          if (p==(int)len) {      if (xe) *xe=eXMLErrorBase64DecodeBufferTooSmall; return false; }
          buf[p++]=(c<<2)|((d>>4)&0x3);
  
          BASE64DECODE_READ_NEXT_CHAR(c)
          if (c==99) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData;  return true; }
          if (p==(int)len)
          {
              if (c==96) return true;
              if (xe) *xe=eXMLErrorBase64DecodeBufferTooSmall;
              return false;
          }
          if (c==96) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData;  return true; }
          buf[p++]=((d<<4)&0xf0)|((c>>2)&0xf);
  
          BASE64DECODE_READ_NEXT_CHAR(d)
          if (d==99 ) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData;  return true; }
          if (p==(int)len)
          {
              if (d==96) return true;
              if (xe) *xe=eXMLErrorBase64DecodeBufferTooSmall;
              return false;
          }
          if (d==96) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData;  return true; }
          buf[p++]=((c<<6)&0xc0)|d;
      }
  }
  #undef BASE64DECODE_READ_NEXT_CHAR
  
  bool XMLParserBase64Tool::decode(const std::string & inString, std::string & outString, XMLError *xe)
  //unsigned char *XMLParserBase64Tool::decode(XMLCSTR data, int *outlen, XMLError *xe)
  {
    if (xe) *xe=eXMLErrorNone;
    unsigned int len=decodeSize(inString.c_str(),xe);
    if (!len) return false;
    outString.resize(len+1,0);
    return decode(inString,(unsigned char *)outString.data(),len,xe);
  }
};
